.TH std::atomic::operator++,++(int),--,--(int) 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::atomic::operator++,++(int),--,--(int) \- std::atomic::operator++,++(int),--,--(int)

.SH Synopsis
   member only of atomic<Integral > specializations
   T operator++() noexcept;                          \fB(1)\fP  \fI(since C++11)\fP
   T operator++() volatile noexcept;                 \fB(2)\fP  \fI(since C++11)\fP
   T operator++( int ) noexcept;                     \fB(3)\fP  \fI(since C++11)\fP
   T operator++( int ) volatile noexcept;            \fB(4)\fP  \fI(since C++11)\fP
   T operator--() noexcept;                          \fB(5)\fP  \fI(since C++11)\fP
   T operator--() volatile noexcept;                 \fB(6)\fP  \fI(since C++11)\fP
   T operator--( int ) noexcept;                     \fB(7)\fP  \fI(since C++11)\fP
   T operator--( int ) volatile noexcept;            \fB(8)\fP  \fI(since C++11)\fP
   member only of atomic<T*> partial specialization
   T* operator++() noexcept;                         \fB(9)\fP  \fI(since C++11)\fP
   T* operator++() volatile noexcept;                \fB(10)\fP \fI(since C++11)\fP
   T* operator++( int ) noexcept;                    \fB(11)\fP \fI(since C++11)\fP
   T* operator++( int ) volatile noexcept;           \fB(12)\fP \fI(since C++11)\fP
   T* operator--() noexcept;                         \fB(13)\fP \fI(since C++11)\fP
   T* operator--() volatile noexcept;                \fB(14)\fP \fI(since C++11)\fP
   T* operator--( int ) noexcept;                    \fB(15)\fP \fI(since C++11)\fP
   T* operator--( int ) volatile noexcept;           \fB(16)\fP \fI(since C++11)\fP

   Atomically increments or decrements the current value. The operation is
   read-modify-write operation.

     * operator++() performs atomic pre-increment. Equivalent to return fetch_add\fB(1)\fP +
       1;.
     * operator++(int) performs atomic post-increment. Equivalent to return
       fetch_add\fB(1)\fP;.
     * operator--() performs atomic pre-decrement. Equivalent to return fetch_sub\fB(1)\fP -
       1;.
     * operator--(int) performs atomic post-decrement. Equivalent to return
       fetch_sub\fB(1)\fP;.
   1-8) For signed integral types, arithmetic is defined to use two’s complement
   representation. There are no undefined results.
   9-16) The result may be an undefined address, but the operations otherwise have no
   undefined behavior.
   If T is not a complete object type, the program is ill-formed.

   It is deprecated if std::atomic<T>::is_always_lock_free is false and   \fI(since C++20)\fP
   any volatile overload participates in overload resolution.

.SH Return value

   operator++() and operator--() return the value of the atomic variable after the
   modification. Formally, the result of incrementing/decrementing the value
   immediately preceding the effects of this function in the modification order of
   *this.

   operator++(int) and operator--(int) return the value of the atomic variable before
   the modification. Formally, the value immediately preceding the effects of this
   function in the modification order of *this.

.SH Notes

   Unlike most pre-increment and pre-decrement operators, the pre-increment and
   pre-decrement operators for atomic types do not return a reference to the modified
   object. They return a copy of the stored value instead.

.SH Example


// Run this code

 #include <atomic>
 #include <chrono>
 #include <iomanip>
 #include <iostream>
 #include <mutex>
 #include <random>
 #include <string>
 #include <thread>

 std::atomic<int> atomic_count{0};

 std::mutex cout_mutex;
 int completed_writes{0};

 constexpr int global_max_count{72};
 constexpr int writes_per_line{8};
 constexpr int max_delay{100};

 template<int Max>
 int random_value()
 {
     static std::uniform_int_distribution<int> distr{1, Max};
     static std::random_device engine;
     static std::mt19937 noise{engine()};
     static std::mutex rand_mutex;
     std::lock_guard lock{rand_mutex};
     return distr(noise);
 }

 int main()
 {
     auto work = [](const std::string id)
     {
         for (int count{}; (count = ++atomic_count) <= global_max_count;)
         {
             std::this_thread::sleep_for(
                 std::chrono::milliseconds(random_value<max_delay>()));

             // print thread `id` and `count` value
             {
                 std::lock_guard lock{cout_mutex};

                 const bool new_line = ++completed_writes % writes_per_line == 0;

                 std::cout << id << std::setw(3) << count << "  "
                           << (new_line ? "\\n" : "") << std::flush;
             }
         }
     };

     std::jthread j1(work, "░"), j2(work, "▒"), j3(work, "▓"), j4(work, "█");
 }

.SH Possible output:

 ▒  2  ░  1  ▒  5  ▒  7  █  4  ░  6  ▓  3  ▒  8
 ▓ 11  █  9  ▓ 13  ░ 10  █ 14  ▒ 12  ░ 16  ░ 19
 ▓ 15  ▒ 18  ▓ 21  ▒ 22  █ 17  █ 25  ▒ 24  █ 26
 ░ 20  ░ 29  ▒ 27  ▓ 23  ▒ 31  ▒ 33  ▓ 32  █ 28
 ░ 30  ░ 37  ▒ 34  ▓ 35  █ 36  █ 41  ▓ 40  ▒ 39
 ░ 38  ▓ 43  █ 42  ▓ 46  ▓ 48  █ 47  █ 50  ░ 45
 ▒ 44  ▒ 53  ▒ 54  ▓ 49  ▒ 55  █ 51  ▒ 57  █ 58
 ░ 52  ▓ 56  ░ 61  ▒ 59  █ 60  ▓ 62  ▒ 64  ░ 63
 ░ 68  ▓ 66  █ 65  █ 71  ▒ 67  ▓ 70  ░ 69  █ 72

   Defect reports

   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.

     DR    Applied to              Behavior as published               Correct behavior
   P0558R1 C++11      arithmetic permitted on pointers to (possibly    made ill-formed
                      cv-qualified) void or function

.SH See also

              atomically adds the argument to the value stored in the atomic object and
   fetch_add  obtains the value held previously
              \fI(public member function)\fP
              atomically subtracts the argument from the value stored in the atomic
   fetch_sub  object and obtains the value held previously
              \fI(public member function)\fP
   operator+= adds to or subtracts from the atomic value
   operator-= \fI(public member function)\fP
   operator&= performs bitwise AND, OR, XOR with the atomic value
   operator|= \fI(public member function)\fP
   operator^=
